/**
 * 错误处理工具
 * 用于捕获和处理各种错误，包括异步组件加载错误
 */

/**
 * 全局错误处理器
 */
export function setupGlobalErrorHandler() {
  // Vue 2 全局错误处理
  if (typeof Vue !== 'undefined') {
    Vue.config.errorHandler = (error, vm, info) => {
      console.error('Vue Error:', error)
      console.error('Component:', vm)
      console.error('Error Info:', info)
      
      // 处理异步组件加载错误
      if (error.message && error.message.includes('AsyncComponentWrapper')) {
        handleAsyncComponentError(error, vm, info)
      }
      
      // 可以在这里上报错误到监控系统
      reportError(error, {
        type: 'vue_error',
        component: vm?.$options?.name || 'unknown',
        info
      })
    }
  }
  
  // 全局未捕获错误处理
  if (typeof window !== 'undefined') {
    window.addEventListener('error', (event) => {
      console.error('Global Error:', event.error)
      reportError(event.error, {
        type: 'global_error',
        filename: event.filename,
        lineno: event.lineno,
        colno: event.colno
      })
    })
    
    // Promise 未捕获错误
    window.addEventListener('unhandledrejection', (event) => {
      console.error('Unhandled Promise Rejection:', event.reason)
      reportError(event.reason, {
        type: 'promise_rejection'
      })
    })
  }
  
  // uni-app 错误处理
  if (typeof uni !== 'undefined') {
    uni.onError((error) => {
      console.error('Uni-app Error:', error)
      reportError(error, {
        type: 'uniapp_error'
      })
    })
  }
}

/**
 * 处理异步组件加载错误
 */
function handleAsyncComponentError(error, vm, info) {
  console.warn('检测到异步组件加载错误，正在尝试修复...')
  
  // 检查是否是导入路径问题
  if (error.message.includes('Cannot find module') || error.message.includes('Module not found')) {
    console.warn('可能是模块导入路径问题，请检查以下文件：')
    console.warn('1. 检查组件导入路径是否正确')
    console.warn('2. 检查文件是否存在')
    console.warn('3. 检查文件名大小写是否正确')
  }
  
  // 检查是否是循环依赖问题
  if (error.message.includes('circular dependency')) {
    console.warn('检测到循环依赖问题')
  }
  
  // 提供修复建议
  provideFixSuggestions(error)
}

/**
 * 提供修复建议
 */
function provideFixSuggestions(error) {
  const suggestions = []
  
  if (error.message.includes('validation.js')) {
    suggestions.push('检查 utils/validation.js 文件是否存在')
    suggestions.push('检查导入路径是否正确，建议使用 @/utils/validation.js')
  }
  
  if (error.message.includes('url-helper.js')) {
    suggestions.push('检查 utils/url-helper.js 文件是否存在')
    suggestions.push('检查导入路径是否正确，建议使用 @/utils/url-helper.js')
  }
  
  if (error.message.includes('performance.js')) {
    suggestions.push('检查 utils/performance.js 文件是否存在')
    suggestions.push('检查导入路径是否正确，建议使用 @/utils/performance.js')
  }
  
  if (suggestions.length > 0) {
    console.warn('修复建议:')
    suggestions.forEach((suggestion, index) => {
      console.warn(`${index + 1}. ${suggestion}`)
    })
  }
}

/**
 * 错误上报
 */
function reportError(error, context = {}) {
  const errorInfo = {
    message: error.message || 'Unknown error',
    stack: error.stack,
    context,
    timestamp: new Date().toISOString(),
    userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : 'unknown',
    url: typeof window !== 'undefined' ? window.location.href : 'unknown'
  }
  
  // 这里可以集成错误上报服务
  // 例如：Sentry、Bugsnag、阿里云ARMS等
  console.log('Error reported:', errorInfo)
  
  // 可以发送到服务器
  // sendErrorToServer(errorInfo)
}

/**
 * 组件错误边界
 */
export function createErrorBoundary(component) {
  return {
    ...component,
    errorCaptured(error, vm, info) {
      console.error('Component Error Captured:', error)
      console.error('Component:', vm)
      console.error('Info:', info)
      
      // 处理异步组件错误
      if (error.message && error.message.includes('AsyncComponentWrapper')) {
        handleAsyncComponentError(error, vm, info)
      }
      
      // 阻止错误继续传播
      return false
    }
  }
}

/**
 * 异步组件包装器
 */
export function createAsyncComponent(loader, options = {}) {
  return () => ({
    component: loader(),
    loading: options.loading || null,
    error: options.error || null,
    delay: options.delay || 200,
    timeout: options.timeout || 3000
  })
}

/**
 * 安全的组件导入
 */
export function safeImport(importFn, fallback = null) {
  return async () => {
    try {
      return await importFn()
    } catch (error) {
      console.error('Component import failed:', error)
      
      // 如果是模块未找到错误，尝试修复路径
      if (error.message.includes('Cannot find module')) {
        console.warn('尝试修复导入路径...')
        // 这里可以添加路径修复逻辑
      }
      
      // 返回fallback组件或错误组件
      if (fallback) {
        return fallback
      }
      
      // 返回一个简单的错误组件
      return {
        template: '<view class="error-component">组件加载失败</view>',
        name: 'ErrorComponent'
      }
    }
  }
}

/**
 * 检查文件是否存在
 */
export function checkFileExists(path) {
  return new Promise((resolve) => {
    // 在小程序环境中，可以尝试导入文件来检查是否存在
    try {
      require(path)
      resolve(true)
    } catch (error) {
      resolve(false)
    }
  })
}

/**
 * 验证导入路径
 */
export function validateImportPath(path) {
  const commonIssues = [
    {
      pattern: /\.\.\/\.\.\/utils\//,
      suggestion: '建议使用 @/utils/ 绝对路径'
    },
    {
      pattern: /\.\.\/components\//,
      suggestion: '建议使用 @/components/ 绝对路径'
    },
    {
      pattern: /\.\.\/\.\.\/components\//,
      suggestion: '建议使用 @/components/ 绝对路径'
    }
  ]
  
  const issues = []
  commonIssues.forEach(({ pattern, suggestion }) => {
    if (pattern.test(path)) {
      issues.push(suggestion)
    }
  })
  
  return issues
}

/**
 * 自动修复导入路径
 */
export function fixImportPath(path) {
  // 修复相对路径为绝对路径
  let fixedPath = path
  
  // 修复 utils 路径
  fixedPath = fixedPath.replace(/\.\.\/\.\.\/utils\//g, '@/utils/')
  fixedPath = fixedPath.replace(/\.\.\/utils\//g, '@/utils/')
  
  // 修复 components 路径
  fixedPath = fixedPath.replace(/\.\.\/\.\.\/components\//g, '@/components/')
  fixedPath = fixedPath.replace(/\.\.\/components\//g, '@/components/')
  
  return fixedPath
}

// 导出工具函数
export default {
  setupGlobalErrorHandler,
  createErrorBoundary,
  createAsyncComponent,
  safeImport,
  checkFileExists,
  validateImportPath,
  fixImportPath
} 